// 格式化工具函数

// 格式化日期
export const formatDate = (date, format = 'YYYY-MM-DD HH:mm:ss') => {
  if (!date) return ''
  
  // 如果是字符串，转换为Date对象
  if (typeof date === 'string') {
    date = new Date(date.replace(/-/g, '/'))
  }
  
  // 如果是数字，转换为Date对象
  if (typeof date === 'number') {
    date = new Date(date)
  }
  
  if (!(date instanceof Date) || isNaN(date.getTime())) {
    return ''
  }
  
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  const hours = String(date.getHours()).padStart(2, '0')
  const minutes = String(date.getMinutes()).padStart(2, '0')
  const seconds = String(date.getSeconds()).padStart(2, '0')
  
  return format
    .replace('YYYY', year)
    .replace('MM', month)
    .replace('DD', day)
    .replace('HH', hours)
    .replace('mm', minutes)
    .replace('ss', seconds)
}

// 格式化时间（相对时间）
export const formatRelativeTime = (date) => {
  if (!date) return ''
  
  // 转换为Date对象
  if (typeof date === 'string') {
    date = new Date(date.replace(/-/g, '/'))
  }
  
  const now = new Date()
  const diff = now.getTime() - date.getTime()
  
  // 计算不同时间单位的差值
  const seconds = Math.floor(diff / 1000)
  const minutes = Math.floor(seconds / 60)
  const hours = Math.floor(minutes / 60)
  const days = Math.floor(hours / 24)
  const months = Math.floor(days / 30)
  const years = Math.floor(days / 365)
  
  // 返回相对时间
  if (years > 0) {
    return years + '年前'
  } else if (months > 0) {
    return months + '个月前'
  } else if (days > 0) {
    return days + '天前'
  } else if (hours > 0) {
    return hours + '小时前'
  } else if (minutes > 0) {
    return minutes + '分钟前'
  } else {
    return seconds + '秒前'
  }
}

// 格式化数字（添加千分位）
export const formatNumber = (num) => {
  if (num === null || num === undefined) return '0'
  
  // 转换为数字
  num = Number(num)
  
  if (isNaN(num)) return '0'
  
  return num.toLocaleString('zh-CN')
}

// 格式化金额
export const formatMoney = (amount, decimals = 2) => {
  if (amount === null || amount === undefined) return '0.00'
  
  // 转换为数字
  amount = Number(amount)
  
  if (isNaN(amount)) return '0.00'
  
  // 保留指定位数的小数
  return amount.toFixed(decimals)
}

// 格式化百分比
export const formatPercent = (value, decimals = 2) => {
  if (value === null || value === undefined) return '0%'
  
  // 转换为数字
  value = Number(value)
  
  if (isNaN(value)) return '0%'
  
  // 乘以100并保留指定位数的小数，添加百分号
  return (value * 100).toFixed(decimals) + '%'
}

// 格式化文件大小
export const formatFileSize = (bytes) => {
  if (bytes === null || bytes === undefined || bytes === 0) return '0 B'
  
  // 转换为数字
  bytes = Number(bytes)
  
  if (isNaN(bytes)) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

// 格式化手机号（中间四位用*代替）
export const formatPhone = (phone) => {
  if (!phone) return ''
  
  // 确保是字符串
  phone = String(phone)
  
  // 匹配手机号格式
  const phoneRegex = /^1[3-9]\d{9}$/
  if (!phoneRegex.test(phone)) return phone
  
  return phone.replace(/(\d{3})\d{4}(\d{4})/, '$1****$2')
}

// 格式化身份证号（中间部分用*代替）
export const formatIdCard = (idCard) => {
  if (!idCard) return ''
  
  // 确保是字符串
  idCard = String(idCard)
  
  // 匹配身份证号格式（15位或18位）
  const idCardRegex = /(\d{6})\d{8,10}(\w{4})/
  if (!idCardRegex.test(idCard)) return idCard
  
  return idCard.replace(idCardRegex, '$1********$2')
}

// 格式化姓名（只显示姓氏，其他用*代替）
export const formatName = (name) => {
  if (!name) return ''
  
  // 确保是字符串
  name = String(name)
  
  if (name.length <= 1) return name
  
  // 只显示第一个字符，其他用*代替
  return name.charAt(0) + '*'.repeat(name.length - 1)
}

// 格式化字符串（截断并添加省略号）
export const truncateString = (str, maxLength = 20, suffix = '...') => {
  if (!str) return ''
  
  // 确保是字符串
  str = String(str)
  
  if (str.length <= maxLength) return str
  
  return str.substring(0, maxLength) + suffix
}

// 格式化URL（隐藏参数等敏感信息）
export const formatUrl = (url) => {
  if (!url) return ''
  
  // 确保是字符串
  url = String(url)
  
  try {
    const parsedUrl = new URL(url)
    // 隐藏查询参数
    if (parsedUrl.search) {
      return parsedUrl.origin + parsedUrl.pathname + '?***'
    }
    return url
  } catch (error) {
    // 如果URL解析失败，返回原URL
    return url
  }
}